{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "60kkM4qXmOKL"
   },
   "source": [
    "## Train and Benchmark and Neural Decoder  with Viterbi Decoder.\n",
    "\n",
    "This notebook contains pipeline how to train a neural decoder model for decoding convolution code over AWGN Channel at 1/2-RSC signal.\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "cyu1oMO5wIML"
   },
   "source": [
    "## Import required packages"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "colab": {
     "autoexec": {
      "startup": false,
      "wait_interval": 0
     }
    },
    "colab_type": "code",
    "id": "iCzr0Es9IfSf"
   },
   "outputs": [],
   "source": [
    "import multiprocessing as mp\n",
    "import time\n",
    "import numpy as np\n",
    "import commpy as cp\n",
    "import tensorflow as tf\n",
    "\n",
    "from deepcom.model import NRSCDecoder           # Neural Decoder Model\n",
    "from deepcom.metrics import BER, BLER           # metrics to benchmark Neural Decoder Model\n",
    "from deepcom.utils import corrupt_signal        # simulate a AWGN Channel\n",
    "\n",
    "from deepcom.dataset import create_dataset      # Create synthetic dataset\n",
    "from deepcom.dataset import data_genenerator    # data loader for Tensorflow\n",
    "\n",
    "import  matplotlib.pyplot  as plt\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "IsrXsYa7lcb6"
   },
   "source": [
    "## Define Hyper-paramemeters for the experiment"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "colab": {
     "autoexec": {
      "startup": false,
      "wait_interval": 0
     }
    },
    "colab_type": "code",
    "id": "X9VFHvkWlhW9"
   },
   "outputs": [],
   "source": [
    "# ########################\n",
    "# Network Architecture\n",
    "# ########################\n",
    "NUM_LAYERS = 2\n",
    "LAYER_TYPE='GRU'\n",
    "DIRECTION='UNIDIRECTIONAL'\n",
    "NUM_HIDDEN_UNITS = 400\n",
    "\n",
    "# ########################\n",
    "# Training Params\n",
    "# #######################\n",
    "BLOCK_LEN = 100\n",
    "NUM_TRAINING_DATA = 120000\n",
    "NUM_TESTING_DATA  = 10000\n",
    "\n",
    "# Hyper-parameters for training\n",
    "BATCH_SIZE = 500       # depends on size of GPU, should be a factor of num_data\n",
    "LEARNING_RATE = 1e-3\n",
    "DROPOUT_RATE= 0.7\n",
    "\n",
    "# Communication Algo via Deep Learning (page 5, last paragraph)\n",
    "SNRs_test = np.linspace(0, 7.0, 8)\n",
    "SNR_train = min(min(SNRs_test), 1.0)\n",
    "\n",
    "CONSTRAINT_LEN = 3     # num of shifts in Conv. Encoder\n",
    "TRACE_BACK_DEPTH = 15  # (?) a parameter Viterbi Encoder"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "VBCUqBHQnru1"
   },
   "source": [
    "## Generate Synthetic Dataset for training/evaluation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "colab": {
     "autoexec": {
      "startup": false,
      "wait_interval": 0
     },
     "base_uri": "https://localhost:8080/",
     "height": 85
    },
    "colab_type": "code",
    "executionInfo": {
     "elapsed": 22629,
     "status": "ok",
     "timestamp": 1529880113413,
     "user": {
      "displayName": "Dat Nguyen",
      "photoUrl": "//lh3.googleusercontent.com/-irIcNYd-KIw/AAAAAAAAAAI/AAAAAAAAAEs/NlM8kG6RL4Q/s50-c-k-no/photo.jpg",
      "userId": "108917076199533451784"
     },
     "user_tz": 420
    },
    "id": "uwbEp-ehnvT8",
    "outputId": "63d819f1-421e-46e8-ade9-9d1221a1556f"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Creating training data....\n",
      "Creating testing data....\n",
      "Number of training sequences 120000\n",
      "Number of testing sequences 10000\n"
     ]
    }
   ],
   "source": [
    "from commpy.channelcoding import Trellis\n",
    "#  Generator Matrix (octal representation)\n",
    "G = np.array([[0o7, 0o5]]) \n",
    "M = np.array([CONSTRAINT_LEN - 1])\n",
    "trellis = Trellis(M, G, feedback=0o7, code_type='rsc')\n",
    "\n",
    "# Create dataset \n",
    "print('Creating training data....')\n",
    "\n",
    "# X_train shape = [NUM_TRAINING_DATA, BLOCK_LENGTH, 2]\n",
    "# Y_train shape = [NUM_TRAINING_DATA, BLOCK_LENGTH, 1]\n",
    "X_train, Y_train = create_dataset(\n",
    "    NUM_TRAINING_DATA, \n",
    "    BLOCK_LEN, \n",
    "    trellis, SNR_train, seed=2018)\n",
    "\n",
    "\n",
    "print('Creating testing data....')\n",
    "# X_test shape = [NUM_TESTING_DATA, BLOCK_LENGTH, 2]\n",
    "# Y_test shape = [NUM_TESTING_DATA, BLOCK_LENGTH, 1]\n",
    "X_test, Y_test = create_dataset(\n",
    "    NUM_TESTING_DATA, \n",
    "    BLOCK_LEN, \n",
    "    trellis, snr=0.0, seed=1111)\n",
    "\n",
    "print('Number of training sequences {}'.format(len(X_train)))\n",
    "print('Number of testing sequences {}'.format(len(Y_test)))\n",
    "# print(X_train.shape, Y_train.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "2fUS4JyEvFVZ"
   },
   "source": [
    "## Define Neural Decoder Model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "colab": {
     "autoexec": {
      "startup": false,
      "wait_interval": 0
     },
     "base_uri": "https://localhost:8080/",
     "height": 340
    },
    "colab_type": "code",
    "executionInfo": {
     "elapsed": 2518,
     "status": "ok",
     "timestamp": 1529880115957,
     "user": {
      "displayName": "Dat Nguyen",
      "photoUrl": "//lh3.googleusercontent.com/-irIcNYd-KIw/AAAAAAAAAAI/AAAAAAAAAEs/NlM8kG6RL4Q/s50-c-k-no/photo.jpg",
      "userId": "108917076199533451784"
     },
     "user_tz": 420
    },
    "id": "uqzVgS7IvH0r",
    "outputId": "f8746742-fc21-4897-a4af-6fd13b7860c4"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "_________________________________________________________________\n",
      "Layer (type)                 Output Shape              Param #   \n",
      "=================================================================\n",
      "input_1 (InputLayer)         (None, None, 2)           0         \n",
      "_________________________________________________________________\n",
      "gru (GRU)                    (None, None, 400)         483600    \n",
      "_________________________________________________________________\n",
      "batch_normalization (BatchNo (None, None, 400)         1600      \n",
      "_________________________________________________________________\n",
      "gru_1 (GRU)                  (None, None, 400)         961200    \n",
      "_________________________________________________________________\n",
      "batch_normalization_1 (Batch (None, None, 400)         1600      \n",
      "_________________________________________________________________\n",
      "time_distributed (TimeDistri (None, None, 1)           401       \n",
      "=================================================================\n",
      "Total params: 1,448,401\n",
      "Trainable params: 1,446,801\n",
      "Non-trainable params: 1,600\n",
      "_________________________________________________________________\n"
     ]
    }
   ],
   "source": [
    "# Construct Neural Decoder\n",
    "inputs = tf.keras.Input(shape=(None, 2))\n",
    "outputs = NRSCDecoder(\n",
    "    inputs, is_training=True, \n",
    "    layer=LAYER_TYPE,\n",
    "    direction=DIRECTION,\n",
    "    num_layers=NUM_LAYERS, \n",
    "    hidden_units=NUM_HIDDEN_UNITS, \n",
    "    dropout=DROPOUT_RATE)\n",
    "model = tf.keras.Model(inputs, outputs)\n",
    "\n",
    "# Set up training \n",
    "model.compile('adam', 'binary_crossentropy', [BER])\n",
    "model.summary()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "L9zfO9Z9vswz"
   },
   "source": [
    "## Start Training/Eval Pipeline"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "colab": {
     "autoexec": {
      "startup": false,
      "wait_interval": 0
     },
     "base_uri": "https://localhost:8080/",
     "height": 51
    },
    "colab_type": "code",
    "id": "lLXl8fC9vul5",
    "outputId": "4c63b55a-79d5-4a78-c75a-79a78213c4b2"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1/100\n",
      "240/240 [==============================] - 88s 367ms/step - loss: 0.3670 - BER: 0.1602 - val_loss: 0.5599 - val_BER: 0.1646\n",
      "Epoch 2/100\n",
      "240/240 [==============================] - 79s 330ms/step - loss: 0.3129 - BER: 0.1355 - val_loss: 0.3448 - val_BER: 0.1346\n",
      "Epoch 3/100\n",
      "240/240 [==============================] - 79s 328ms/step - loss: 0.3048 - BER: 0.1316 - val_loss: 0.2969 - val_BER: 0.1278\n",
      "Epoch 4/100\n",
      "240/240 [==============================] - 78s 325ms/step - loss: 0.3022 - BER: 0.1304 - val_loss: 0.2968 - val_BER: 0.1277\n",
      "Epoch 5/100\n",
      "240/240 [==============================] - 78s 325ms/step - loss: 0.3006 - BER: 0.1296 - val_loss: 0.2956 - val_BER: 0.1269\n",
      "Epoch 6/100\n",
      "240/240 [==============================] - 78s 326ms/step - loss: 0.2995 - BER: 0.1291 - val_loss: 0.2954 - val_BER: 0.1269\n",
      "Epoch 7/100\n",
      "240/240 [==============================] - 79s 327ms/step - loss: 0.2987 - BER: 0.1287 - val_loss: 0.2954 - val_BER: 0.1269\n",
      "Epoch 8/100\n",
      "240/240 [==============================] - 78s 326ms/step - loss: 0.2982 - BER: 0.1285 - val_loss: 0.2950 - val_BER: 0.1269\n",
      "Epoch 9/100\n",
      "240/240 [==============================] - 78s 326ms/step - loss: 0.2977 - BER: 0.1283 - val_loss: 0.2952 - val_BER: 0.1272\n",
      "Epoch 10/100\n",
      "240/240 [==============================] - 79s 329ms/step - loss: 0.2973 - BER: 0.1282 - val_loss: 0.2948 - val_BER: 0.1270\n",
      "Epoch 11/100\n",
      "240/240 [==============================] - 79s 329ms/step - loss: 0.2969 - BER: 0.1280 - val_loss: 0.2955 - val_BER: 0.1271\n",
      "Epoch 12/100\n",
      "240/240 [==============================] - 78s 325ms/step - loss: 0.2968 - BER: 0.1278 - val_loss: 0.2950 - val_BER: 0.1268\n",
      "Epoch 13/100\n",
      "240/240 [==============================] - 78s 325ms/step - loss: 0.2965 - BER: 0.1277 - val_loss: 0.2948 - val_BER: 0.1271\n"
     ]
    }
   ],
   "source": [
    "# Set up Data Loader using tf.Dataset\n",
    "train_set = data_genenerator(X_train, Y_train, BATCH_SIZE, shuffle=True)\n",
    "test_set = data_genenerator(X_test, Y_test, BATCH_SIZE, shuffle=False)\n",
    "\n",
    "# Backup best model\n",
    "backup = tf.keras.callbacks.ModelCheckpoint(                     \n",
    "  filepath='UniGRU.hdf5',\n",
    "  monitor='val_BER',\n",
    "  save_best_only=True)\n",
    "    \n",
    "# Stop training early if the model seems to overfit\n",
    "early_stopping = tf.keras.callbacks.EarlyStopping(\n",
    "    monitor='val_loss',\n",
    "    min_delta=0.0,\n",
    "    patience=3,\n",
    "    verbose=0, mode='auto')\n",
    "\n",
    "history = model.fit(\n",
    "    train_set.make_one_shot_iterator(), \n",
    "    steps_per_epoch=len(X_train) //BATCH_SIZE, \n",
    "    validation_data=test_set.make_one_shot_iterator(),\n",
    "    validation_steps= len(X_test) //BATCH_SIZE,\n",
    "    callbacks=[early_stopping, backup],\n",
    "    epochs=100)\n",
    "\n",
    "model = tf.keras.models.load_model('UniGRU.hdf5',{'BER': BER})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "colab": {
     "autoexec": {
      "startup": false,
      "wait_interval": 0
     },
     "base_uri": "https://localhost:8080/",
     "height": 387
    },
    "colab_type": "code",
    "executionInfo": {
     "elapsed": 1105,
     "status": "ok",
     "timestamp": 1529874947100,
     "user": {
      "displayName": "Dat Nguyen",
      "photoUrl": "//lh3.googleusercontent.com/-irIcNYd-KIw/AAAAAAAAAAI/AAAAAAAAAEs/NlM8kG6RL4Q/s50-c-k-no/photo.jpg",
      "userId": "108917076199533451784"
     },
     "user_tz": 420
    },
    "id": "UheNmuX9isBo",
    "outputId": "7e6287e3-aab3-4150-cd79-0b2545b27fe4"
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x432 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 432x288 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Count of the number of epochs\n",
    "epochs = range(1, len(history.history['loss']) + 1)\n",
    "# Visualize loss history\n",
    "plt.figure(figsize=(8, 6))\n",
    "plt.plot(epochs, history.history['loss'], 'r--')\n",
    "plt.plot(epochs, history.history['val_loss'], 'b-')\n",
    "plt.legend(['Training Loss', 'Test Loss'])\n",
    "plt.xlabel('Epoch')\n",
    "plt.ylabel('Loss')\n",
    "plt.grid()\n",
    "plt.show()\n",
    "plt.savefig('training_result.png')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "_CsQHyoH4nGO"
   },
   "source": [
    "## Benchmark Neural Decoder"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "colab": {
     "autoexec": {
      "startup": false,
      "wait_interval": 0
     },
     "base_uri": "https://localhost:8080/",
     "height": 36
    },
    "colab_type": "code",
    "executionInfo": {
     "elapsed": 693,
     "status": "ok",
     "timestamp": 1529874948606,
     "user": {
      "displayName": "Dat Nguyen",
      "photoUrl": "//lh3.googleusercontent.com/-irIcNYd-KIw/AAAAAAAAAAI/AAAAAAAAAEs/NlM8kG6RL4Q/s50-c-k-no/photo.jpg",
      "userId": "108917076199533451784"
     },
     "user_tz": 420
    },
    "id": "iteYs2bU5EZx",
    "outputId": "f2736499-7d68-4728-c0fd-a5d9fa3be680"
   },
   "outputs": [],
   "source": [
    "def benchmark_neural_decoder(noisy_inputs, labels):\n",
    "    \n",
    "    # Set up data generator\n",
    "    Y = np.reshape(labels, (-1, BLOCK_LEN, 1))\n",
    "    X = np.reshape(np.array(noisy_inputs)[:, :2*BLOCK_LEN], (-1, BLOCK_LEN, 2))\n",
    "    test_set = data_genenerator(X, Y, BATCH_SIZE, shuffle=False)\n",
    "    \n",
    "    # Make predictions on batch\n",
    "    decoded_bits = model.predict(\n",
    "        test_set.make_one_shot_iterator(), \n",
    "        steps=len(Y) // BATCH_SIZE)\n",
    "    \n",
    "    # Compute hamming distances\n",
    "    original_bits = np.reshape(Y, (-1, BLOCK_LEN)).astype(int)\n",
    "    decoded_bits =  np.reshape(np.round(decoded_bits), (-1, BLOCK_LEN)).astype(int)\n",
    "    hamming_dist = np.not_equal(original_bits, decoded_bits)\n",
    "    \n",
    "    return np.sum(hamming_dist, axis=1)\n",
    "\n",
    "def benchmark_viterbi(message_bits, noisy_bits, sigma):\n",
    "  \n",
    "    # make fair comparison between (100, 204) convolutional code and RNN decoder\n",
    "    # Reference: Author's code\n",
    "    noisy_bits[-2*int(M):] = 0\n",
    "    \n",
    "    # Viterbi Decoder on Conv. Code\n",
    "    decoded_bits = cp.channelcoding.viterbi_decode(\n",
    "        coded_bits=noisy_bits.astype(float), \n",
    "        trellis=trellis,\n",
    "        tb_depth=TRACE_BACK_DEPTH,\n",
    "        decoding_type='unquantized')\n",
    "    \n",
    "    # Number of bit errors (hamming distance)\n",
    "    hamming_dist = cp.utilities.hamming_dist(\n",
    "        message_bits.astype(int),\n",
    "        decoded_bits[:-int(M)])\n",
    "    return hamming_dist\n",
    "\n",
    " \n",
    "# #################################################################\n",
    "# For every SNR_db, we generates new noisy signals\n",
    "# for fair comparision.\n",
    "# #################################################################\n",
    "def generate_noisy_input(message_bits, trellis, sigma):\n",
    "    # Encode message bit\n",
    "    coded_bits = cp.channelcoding.conv_encode(message_bits, trellis)\n",
    "    # Corrupt message on BAWGN Channel\n",
    "    coded_bits = corrupt_signal(coded_bits, noise_type='awgn', sigma=sigma)\n",
    "    return coded_bits, message_bits"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "colab": {
     "autoexec": {
      "startup": false,
      "wait_interval": 0
     },
     "base_uri": "https://localhost:8080/",
     "height": 216
    },
    "colab_type": "code",
    "executionInfo": {
     "elapsed": 938376,
     "status": "ok",
     "timestamp": 1529875887369,
     "user": {
      "displayName": "Dat Nguyen",
      "photoUrl": "//lh3.googleusercontent.com/-irIcNYd-KIw/AAAAAAAAAAI/AAAAAAAAAEs/NlM8kG6RL4Q/s50-c-k-no/photo.jpg",
      "userId": "108917076199533451784"
     },
     "user_tz": 420
    },
    "id": "gkTTBO0nvxAi",
    "outputId": "eb1b9114-d056-4ec5-c7e8-8a5ba16af9e2"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[SNR]=0.00\n",
      "\tNeural Decoder:  [BER]=0.0618407 [BLER]=1.000 -- 4.134s\n",
      "\tViterbi Decoder: [BER]=0.0899850 [BLER]=0.953 -- 43.739s\n",
      "[SNR]=1.00\n",
      "\tNeural Decoder:  [BER]=0.0440103 [BLER]=0.999 -- 4.367s\n",
      "\tViterbi Decoder: [BER]=0.0467100 [BLER]=0.783 -- 43.897s\n",
      "[SNR]=2.00\n",
      "\tNeural Decoder:  [BER]=0.0283946 [BLER]=0.990 -- 4.186s\n",
      "\tViterbi Decoder: [BER]=0.0188540 [BLER]=0.473 -- 42.363s\n",
      "[SNR]=3.00\n",
      "\tNeural Decoder:  [BER]=0.0165843 [BLER]=0.944 -- 4.321s\n",
      "\tViterbi Decoder: [BER]=0.0061200 [BLER]=0.197 -- 44.245s\n",
      "[SNR]=4.00\n",
      "\tNeural Decoder:  [BER]=0.0085074 [BLER]=0.774 -- 4.776s\n",
      "\tViterbi Decoder: [BER]=0.0014100 [BLER]=0.058 -- 43.485s\n",
      "[SNR]=5.00\n",
      "\tNeural Decoder:  [BER]=0.0038363 [BLER]=0.513 -- 4.519s\n",
      "\tViterbi Decoder: [BER]=0.0002260 [BLER]=0.013 -- 43.989s\n",
      "[SNR]=6.00\n",
      "\tNeural Decoder:  [BER]=0.0013833 [BLER]=0.232 -- 4.407s\n",
      "\tViterbi Decoder: [BER]=0.0000720 [BLER]=0.005 -- 43.037s\n",
      "[SNR]=7.00\n",
      "\tNeural Decoder:  [BER]=0.0004176 [BLER]=0.079 -- 4.550s\n",
      "\tViterbi Decoder: [BER]=0.0000090 [BLER]=0.001 -- 42.237s\n"
     ]
    }
   ],
   "source": [
    "viterbiBERs, viterbiBLERs = [], []\n",
    "neuralBERs, neuralBLERs = [], []\n",
    "\n",
    "pool = mp.Pool(processes=mp.cpu_count())\n",
    "labels = np.reshape(Y_test, (-1, BLOCK_LEN)).astype(int)\n",
    "try: \n",
    "    SNRs  = np.linspace(0, 7.0, 8)\n",
    "    for snr in SNRs:\n",
    "        snr_linear = snr + 10 * np.log10(1./2.)\n",
    "        sigma = np.sqrt(1. / (2. * 10 **(snr_linear / 10.)))\n",
    "        print('[SNR]={:.2f}'.format(snr))\n",
    "        \n",
    "        # Generates new noisy signals\n",
    "        result = pool.starmap(\n",
    "            func=generate_noisy_input,  \n",
    "            iterable=[(msg_bits, trellis, sigma) for msg_bits in labels])\n",
    "        \n",
    "        X, Y =  zip(*result)\n",
    "        \n",
    "        # #################################################################\n",
    "        # BENCHMARK NEURAL DECODER \n",
    "        # #################################################################\n",
    "        nn_start = time.time()\n",
    "        hamm_dists = benchmark_neural_decoder(X, Y)\n",
    "        nn_ber = sum(hamm_dists) / np.product(np.shape(X))\n",
    "        nn_bler = np.count_nonzero(hamm_dists) / len(X)\n",
    "\n",
    "        neuralBERs.append(nn_ber)\n",
    "        neuralBLERs.append(nn_bler)            \n",
    "        print('\\tNeural Decoder:  [BER]={:5.7f} [BLER]={:5.3f} -- {:3.3f}s'.format(\n",
    "            nn_ber, nn_bler, time.time() - nn_start)) \n",
    "\n",
    "        # #################################################################\n",
    "        # BENCHMARK VITERBI DECODER \n",
    "        # #################################################################\n",
    "        vi_start = time.time()\n",
    "        hamm_dists = pool.starmap(benchmark_viterbi, [(y, x, sigma) for x, y in zip(X, Y)])\n",
    "        # Bit error rate\n",
    "        ber = sum(hamm_dists) / np.product(np.shape(Y))\n",
    "        # Block error rate\n",
    "        bler = np.count_nonzero(hamm_dists) / len(Y)\n",
    "        viterbiBERs.append(ber)\n",
    "        viterbiBLERs.append(bler)\n",
    "        print('\\tViterbi Decoder: [BER]={:5.7f} [BLER]={:5.3f} -- {:3.3f}s'.format(\n",
    "              ber, bler, time.time() - vi_start))\n",
    "        \n",
    "except Exception as e:\n",
    "    print(e)\n",
    "finally:\n",
    "    pool.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "T0cL-ORChXne"
   },
   "source": [
    "# Result"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1296x504 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# ###################################\n",
    "# Plot Bit Error Rate (BER) Curve\n",
    "# ###################################\n",
    "plt.figure(figsize=(18, 7))\n",
    "\n",
    "plt.subplot(1, 2, 1)\n",
    "plt.title('Block Length = 100 || Data rate = 1/2', fontsize=14)\n",
    "\n",
    "plt.semilogy(SNRs, neuralBERs, '-vr')\n",
    "plt.semilogy(SNRs, viterbiBERs, 's--')\n",
    "plt.legend(['N-RSC (SNR_train=0 dB)', 'Viterbi'], fontsize=16)\n",
    "plt.xlabel('SNR', fontsize=16)\n",
    "plt.xlim(xmin=SNRs[0], xmax=SNRs[-1])  # this line\n",
    "plt.ylabel('BER', fontsize=16)\n",
    "plt.grid(True, which='both')\n",
    "plt.savefig('result_ber_block_length_1000_snr0.png')\n",
    "\n",
    "# ###################################\n",
    "# Plot Block Error Rate (BLER) Curve\n",
    "# ###################################\n",
    "plt.subplot(1, 2, 2)\n",
    "plt.title('Block Length = 100 || Data rate = 1/2', fontsize=14)\n",
    "\n",
    "plt.semilogy(SNRs, neuralBLERs, '-vr')\n",
    "plt.semilogy(SNRs, viterbiBLERs, 's--')\n",
    "plt.ylabel('BLER', fontsize=16)\n",
    "plt.xlabel('SNR', fontsize=16)\n",
    "plt.legend(['N-RSC (SNR_train=0 dB)', 'Viterbi'], fontsize=16)\n",
    "\n",
    "plt.xlim(xmin=SNRs[0], xmax=SNRs[-1])  # this line\n",
    "plt.grid(True, which='both')\n",
    "plt.savefig('result_bler_block_length_1000_snr0.png')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "accelerator": "GPU",
  "colab": {
   "collapsed_sections": [],
   "default_view": {},
   "name": "train_neural_decoder.ipynb",
   "provenance": [],
   "version": "0.3.2",
   "views": {}
  },
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}
